package com.miplus.ccrm.core.service.aiqm;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.miplus.ccrm.common.CmdResVo;
import com.miplus.ccrm.common.EnumRCode;
import com.miplus.ccrm.common.ServiceException;
import com.miplus.ccrm.core.api.aiyun.DashScopeApi;
import com.miplus.ccrm.core.api.aiyun.model.ChatRequest;
import com.miplus.ccrm.core.api.aiyun.model.QmModelSummary;
import com.miplus.ccrm.core.api.aiyun.model.QualityScoreInfo;
import com.miplus.ccrm.core.api.filetrans.FileTransApi;
import com.miplus.ccrm.core.api.filetrans.model.FileTransResponseResult;
import com.miplus.ccrm.core.controller.vo.aiqm.*;
import com.miplus.ccrm.core.pojo.*;
import com.miplus.ccrm.core.mapper.QmFileTaskMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;

/**
 * @author 20144
 * @description 针对表【QM_FILE_TASK(质检数据文件URL任务表)】的数据库操作Service实现
 * @createDate 2025-08-21 14:49:16
 */
@Slf4j
@Service
public class QmFileTaskServiceImpl extends MPJBaseServiceImpl<QmFileTaskMapper, QmFileTask>
        implements QmFileTaskService {
    @Resource
    private QmTemplateService qmTempService;

    @Resource
    private QmModelRulesLinkService qmModelRulesLinkService;


    @Resource
    private QmRulesService qmRulesService;

    @Override
    public CmdResVo createQmTask(String usrid, QmCrtTaskReqVo paras) {
        QmFileTask def = new QmFileTask();
        BeanUtils.copyProperties(paras, def);
        def.setRecordfileurl(paras.getFileurl());
        def.setTemplateid(paras.getTemplateid());
        // 质检状态：未质检
        def.setQmstatus("uncheck");
        def.setCreatetime(new Date());
        def.setQmuser(usrid);
        def.setCrusr(usrid);
        int ret = baseMapper.insert(def);
        // 创建完成任务后，异步执行转写和质检
        // 获取创建的任务id，先异步转写文本
        new Thread(() -> {
            try {
                // 执行转写
                processtartTranscript(def.getQmtaskid().toString(), paras.getFileurl());
                // 转写完成后，提交质检任务
                processsubmitQmTask(paras.getTemplateid(), def.getQmtaskid());
            } catch (Exception e) {
                log.error("异步处理任务出错，任务ID: {}", def.getQmtaskid(), e);
                // 出错时更新任务状态
                QmFileTask errorTask = new QmFileTask();
                errorTask.setQmtaskid(def.getQmtaskid());
                errorTask.setQmstatus("error");
                baseMapper.updateById(errorTask);
            }
        }, "QmTask-Creator-" + def.getQmtaskid()).start();

        return new CmdResVo(ret, def.getQmtaskid().toString());
    }

    @Override
    public IPage<QmTaskListResVo> qmTaskList(QmTaskReqVo paras) {
        // 处理分页参数，提供默认值避免空指针
        int pageNum = Optional.ofNullable(paras.getPageNum()).orElse(1);
        int pageSize = Optional.ofNullable(paras.getPageSize()).orElse(10);
        // 构建分页对象
        Page<QmTaskListResVo> page = new Page<>(pageNum, pageSize);
        // 使用MPJLambdaWrapper构建联表查询条件
        MPJLambdaWrapper<QmFileTask> wrapper = new MPJLambdaWrapper<QmFileTask>()
                .selectAll(QmFileTask.class)
                // 显式指定需要从关联表查询的字段，避免字段冲突
                .selectAs(QmTemplate::getTemplatename, QmTaskListResVo::getTemplatename)
                .leftJoin(QmTemplate.class, QmTemplate::getTemplateid, QmFileTask::getTemplateid)
                .orderByAsc(QmFileTask::getCreatetime);

        // 模板ID查询条件
        Optional.ofNullable(paras.getTemplateid())
                .ifPresent(templateId -> wrapper.eq(QmFileTask::getTemplateid, templateId));

        // 状态查询条件
        Optional.ofNullable(paras.getQmstatus())
                .ifPresent(status -> wrapper.eq(QmFileTask::getQmstatus, status));

        if (paras.getStartdt() != null && paras.getEnddt() != null) {
            wrapper.apply("t.createtime BETWEEN TO_DATE({0}, 'YYYY-MM-DD') AND TO_DATE({1}, 'YYYY-MM-DD') + 1 - INTERVAL '1' SECOND",
                    paras.getStartdt(), paras.getEnddt());
        }
        // 质检时间查询条件
        if (paras.getQmstartdt() != null && paras.getQmenddt() != null) {
            wrapper.apply("t.qmdatetime BETWEEN TO_DATE({0}, 'YYYY-MM-DD') AND TO_DATE({1}, 'YYYY-MM-DD') + 1 - INTERVAL '1' SECOND",
                    paras.getQmstartdt(), paras.getQmenddt());
        }

        // 执行联表分页查询
        return selectJoinListPage(page, QmTaskListResVo.class, wrapper);
    }

    @Override
    public QmTaskResVo qmTaskDetail(String qmtaskid) {
        QmFileTask task = baseMapper.selectById(qmtaskid);
        if (task == null) {
            throw new ServiceException(EnumRCode.NoFindData.value, EnumRCode.NoFindData.name);
        }
        String transcripttxt = task.getTranscripttxtclob();//这是个数组格式，返回前端是个列表
        List<FileTransResponseResult.SentenceInfo> sentenceList = JSONUtil.toList(transcripttxt, FileTransResponseResult.SentenceInfo.class);
        sentenceList.parallelStream().forEach(i -> {
            ForbiddenWordsReqVo reqVo = new ForbiddenWordsReqVo();
            reqVo.setText(i.getText());
            ForbiddenWordsReqVo forbiddenWordsReqVo = qmRulesService.forbiddenWordsCheck(reqVo);
            i.setText(forbiddenWordsReqVo.getText());
        });

        //转换小结为对象
        QmModelSummary modelSummary = JSONUtil.toBean(task.getModelsummary(), QmModelSummary.class);
        //转换质检分数为对象
        QualityScoreInfo qualityScoreInfo = JSONUtil.toBean(task.getQualityscore(), QualityScoreInfo.class);
        String templatename = qmTempService.getById(task.getTemplateid()).getTemplatename();
        QmTaskResVo res = new QmTaskResVo();
        BeanUtils.copyProperties(task, res, "transcripttxtclob", "transcripttxt");
        res.setTemplatename(templatename);
        res.setSentenceInfoList(sentenceList);
        res.setModelSummary(modelSummary);
        res.setQualityScoreInfo(qualityScoreInfo);
        return res;
    }


    /**
     * 异步处理任务
     * @param
     */

    public void processsubmitQmTask(Integer templateid, Long qmtaskid) {
        // 1. 先更新任务状态为"处理中"
        QmFileTask task = new QmFileTask();
        task.setQmtaskid(qmtaskid);
        task.setQmstatus("processing");
        task.setQmdatetime(new Date());
        baseMapper.updateById(task);
        // 2. 手动创建线程执行任务处理逻辑
        new Thread(() -> {
            try {
                processQmTaskAsync(templateid, qmtaskid);
            } catch (Exception e) {
                log.error("异步处理任务出错", e);
                // 出错时更新任务状态
                QmFileTask errorTask = new QmFileTask();
                errorTask.setQmtaskid(qmtaskid);
                errorTask.setQmstatus("error");
                baseMapper.updateById(errorTask);
            }
        }, "QmTask-Processor-" + qmtaskid).start();
    }

    /**
     * 异步执行质检任务
     */
    public void processQmTaskAsync(Integer templateid, Long qmtaskid) {
        try {
            // 1.根据模版id，查询大模型任务描述
            QmTemplate qmTemplate = qmTempService.getById(templateid);
            if (qmTemplate == null) {
                log.error("模板不存在，templateid: {}", templateid);
                // 更新任务状态为失败
                return;
            }
            BigDecimal adoptscore = qmTemplate.getAdoptscore();
            String hasadvantageremark = qmTemplate.getHasadvantageremark();
            String hasimproveremark = qmTemplate.getHasimproveremark();
            String hasqaremark = qmTemplate.getHasqaremark();
            String promptTemplate = qmTemplate.getModeltask();
            // 2.根据模版id，获取大模型主规则和子规则
            List<QmModelRulesResVo> qmModelRulesResVoList = qmModelRulesLinkService.qmModelRulesLinkService(templateid);
            // 2.1处理质检规则，转换为指定格式的字符串
            StringBuilder rulesBuilder = new StringBuilder();
            BigDecimal totalScoreSum = BigDecimal.ZERO;
            int ruleIndex = 1;

            if (CollectionUtils.isNotEmpty(qmModelRulesResVoList)) {
                for (QmModelRulesResVo mainRule : qmModelRulesResVoList) {
                    // 累加主规则下的总分
                    if (mainRule.getTotalscore() != null) {
                        totalScoreSum = totalScoreSum.add(mainRule.getTotalscore());
                    }
                    // 处理子规则
                    List<QmModelRulesResVo.QmModelRulesSubResVo> subRules = mainRule.getQasubrules();
                    if (CollectionUtils.isNotEmpty(subRules)) {
                        for (QmModelRulesResVo.QmModelRulesSubResVo subRule : subRules) {
                            // 转换检测角色为中文描述
                            String qmRoleDesc;
                            switch (subRule.getQmrole()) {
                                case "0":
                                    qmRoleDesc = "坐席和客户";
                                    break;
                                case "1":
                                    qmRoleDesc = "坐席";
                                    break;
                                case "2":
                                    qmRoleDesc = "客户";
                                    break;
                                default:
                                    qmRoleDesc = "未知";
                            }

                            // 拼接规则字符串
                            rulesBuilder.append(ruleIndex)
                                    .append(".质检项ID：").append(subRule.getQasubid())
                                    .append(",质检对象：").append(qmRoleDesc)
                                    .append(",规则：").append(subRule.getAssessscheme())
                                    .append("\n");
                            ruleIndex++;
                        }
                    }
                }
            }
            String rulesText = rulesBuilder.toString();
            log.info("处理后的质检规则：{},质检总分：{}", rulesText, totalScoreSum);
            // 3.获取质检任务的转写文本
            QmFileTask qmFileTask = baseMapper.selectById(qmtaskid);
            if (qmFileTask == null) {
                log.error("任务不存在，qmtaskid: {}", qmtaskid);
                return;
            }
            String transcripttxtclob = qmFileTask.getTranscripttxtclob();
            if (StrUtil.isBlank(transcripttxtclob)) {
                log.error("任务转写文本为空，qmtaskid: {}", qmtaskid);
                return;
            }
            List<FileTransResponseResult.SentenceInfo> sentenceList = JSONUtil.toList(transcripttxtclob, FileTransResponseResult.SentenceInfo.class);

            // 3.1 转换任务对话文本
            StringBuilder dialogueBuilder = new StringBuilder();
            if (CollectionUtils.isNotEmpty(sentenceList)) {
                for (FileTransResponseResult.SentenceInfo sentence : sentenceList) {
                    // 转换说话人标识为中文角色
                    String speakerRole = "未知";
                    if ("1".equals(sentence.getSpeakerId())) {
                        speakerRole = "坐席";
                    } else if ("2".equals(sentence.getSpeakerId())) {
                        speakerRole = "客户";
                    }

                    // 拼接主要对话内容行
                    dialogueBuilder.append(speakerRole).append("： 说话内容：")
                            .append(sentence.getText() == null ? "" : sentence.getText()).append("。\n");

                    // 拼接详细信息行
                    dialogueBuilder.append(speakerRole).append(" （语速：").append(sentence.getSpeechRate())
                            .append("/ 情绪：").append(sentence.getEmotionValue() / 10.0)
                            .append("/ 静音时长：").append(sentence.getSilenceDuration())
                            .append(" /  开始时间（毫秒）：").append(sentence.getBeginTime())
                            .append(" / 结束时间（毫秒）：").append(sentence.getEndTime()).append("\n");
                }
            }
            String formattedDialogue = dialogueBuilder.toString();
            log.info("转换后的对话文本：{}", formattedDialogue);

            // 4.拼接大模型提示词
            String finalPrompt = promptTemplate
                    .replace("${text}", formattedDialogue)
                    .replace("${normal}", rulesText);
            // 处理可能存在的禁忌项变量
            if (finalPrompt.contains("${taboo}")) {
                finalPrompt = finalPrompt.replace("${taboo}", ""); // 若有禁忌项可在此处替换
            }
            log.info("最终的提示词：{}", finalPrompt);

            // 5.调用大模型
            ChatRequest chatRequest = new ChatRequest();
            chatRequest.setModel("qwen-max");
            chatRequest.setSystemPrompt("你是一个专业的质检助手,按照格式输出质检结果");
            chatRequest.setUserPrompt(finalPrompt);
            log.info("调用大模型");
            GenerationResult generationResult = DashScopeApi.callWithMessage(chatRequest);
            String modelSummary = generationResult.getOutput().getChoices().get(0).getMessage().getContent();
            log.info("大模型返回结果：{}", modelSummary);

            // 6.解析大模型结果并计算分数
            QmModelSummary modelSummaryjson = JSONUtil.toBean(modelSummary, QmModelSummary.class);
            BigDecimal scoreSum = modelSummaryjson.getScores().stream()
                    .map(scoreItem -> {
                        try {
                            return new BigDecimal(scoreItem.getScore());
                        } catch (NumberFormatException e) {
                            log.error("分数格式错误: {}", scoreItem.getScore(), e);
                            return BigDecimal.ZERO;
                        }
                    })
                    .reduce(BigDecimal.ZERO, BigDecimal::add);

            // 7.构建质检分数信息
            QualityScoreInfo qualityScoreInfo = new QualityScoreInfo();
            qualityScoreInfo.setPassScore(adoptscore != null ? adoptscore : BigDecimal.ZERO);
            qualityScoreInfo.setTotalDeduction(scoreSum);
            //qualityScoreInfo.setActualScore(totalScoreSum.subtract(scoreSum));
            qualityScoreInfo.setActualScore(scoreSum);// 修改为实际得分
            // 8.更新任务表字段
            QmFileTask updateTask = new QmFileTask();
            updateTask.setQmtaskid(qmtaskid);
            updateTask.setModelsummary(modelSummary);
            updateTask.setQualityscore(JSONUtil.toJsonStr(qualityScoreInfo));
            updateTask.setModeltaskdesc(finalPrompt);
            //判断是否 通过  质检合格 qualified / 质检不合格 unqualified
            //（总分-扣分）  大于等于   adoptScore  质检合格
            //修改为  实际得分  大于等于   adoptScore  质检合格
            if (scoreSum.compareTo(adoptscore) >= 0) {
                updateTask.setQmresult("qualified");
            } else {
                updateTask.setQmresult("unqualified");
            }
//            if (totalScoreSum.subtract(scoreSum).compareTo(adoptscore) >= 0) {
//                updateTask.setQmresult("qualified");
//            } else {
//                updateTask.setQmresult("unqualified");
//            }
            //完成
            updateTask.setQmstatus("finish");
            baseMapper.updateById(updateTask);

            log.info("质检任务处理完成，qmtaskid: {}", qmtaskid);

        } catch (NoApiKeyException e) {
            log.error("API密钥错误，任务处理失败", e);
        } catch (InputRequiredException e) {
            log.error("输入参数错误，任务处理失败", e);
        } catch (Exception e) {
            log.error("质检任务处理异常，qmtaskid: {}", qmtaskid, e);
        }
    }




/**
 * 异步转写任务
 */
public void processtartTranscript(String qmtaskid,String fileurl) {
    //1.根据任务id，查询任务信息
    QmFileTask qmFileTask = baseMapper.selectById(qmtaskid);
    if (qmFileTask == null) {
        log.warn("任务不存在");
    }
    //如果没有转写文本启动转写
    if (qmFileTask.getTranscripttxtclob() == null) {
        //调取转写api
        try {
            FileTransResponseResult fileTransResponseResult = FileTransApi.processFileTrans(fileurl);
            assert fileTransResponseResult != null;
            List<FileTransResponseResult.SentenceInfo> sentenceList = fileTransResponseResult.getSentenceInfos();
            String jsonArray = JSONUtil.toJsonStr(sentenceList);
            qmFileTask.setTranscripttxtclob(jsonArray);
            baseMapper.updateById(qmFileTask);
        } catch (Exception e) {
            throw new RuntimeException("转写失败,录音文件异常", e);
        }
    }
}





    /**
     * 提交质检任务
     *
     * @param paras
     * @return
     */
//    @Override
//    public CmdResVo submitQmTask(QmSubmitTaskReqVo paras) throws NoApiKeyException, InputRequiredException {
//        Integer templateid = paras.getTemplateid(); //模版id
//        Long qmtaskid = paras.getQmtaskid();  //任务id
//        //1.根据模版id，取查询大模型任务描述
//        QmTemplate qmTemplate = qmTempService.getById(templateid);
//        BigDecimal adoptscore = qmTemplate.getAdoptscore();
//        String hasadvantageremark = qmTemplate.getHasadvantageremark();
//        String hasimproveremark = qmTemplate.getHasimproveremark();
//        String hasqaremark = qmTemplate.getHasqaremark();
//        String promptTemplate = qmTemplate.getModeltask(); //模型任务提示词。取出来需要拼接大模型主规则和子规则和对话文本
//        //2.根据模版id，取大模型主规则和子规则
//        List<QmModelRulesResVo> qmModelRulesResVoList = qmModelRulesLinkService.qmModelRulesLinkService(templateid);
//        // 2.1处理质检规则，转换为指定格式的字符串
//        StringBuilder rulesBuilder = new StringBuilder();
//        BigDecimal totalScoreSum = BigDecimal.ZERO;
//        int ruleIndex = 1;
//        if (CollectionUtils.isNotEmpty(qmModelRulesResVoList)) {
//            for (QmModelRulesResVo mainRule : qmModelRulesResVoList) {
//                // 累加主规则下的总分
//                if (mainRule.getTotalscore() != null) {
//                    totalScoreSum = totalScoreSum.add(mainRule.getTotalscore());
//                }
//                // 处理子规则
//                List<QmModelRulesResVo.QmModelRulesSubResVo> subRules = mainRule.getQasubrules();
//                if (CollectionUtils.isNotEmpty(subRules)) {
//                    for (QmModelRulesResVo.QmModelRulesSubResVo subRule : subRules) {
//                        // 转换检测角色为中文描述
//                        String qmRoleDesc;
//                        switch (subRule.getQmrole()) {
//                            case "0":
//                                qmRoleDesc = "坐席和客户";
//                                break;
//                            case "1":
//                                qmRoleDesc = "坐席";
//                                break;
//                            case "2":
//                                qmRoleDesc = "客户";
//                                break;
//                            default:
//                                qmRoleDesc = "未知";
//                        }
//                        // 拼接规则字符串
//                        rulesBuilder.append(ruleIndex)
//                                .append(".质检项ID：").append(subRule.getQasubid())
//                                .append(",质检对象：").append(qmRoleDesc)
//                                .append(",规则：").append(subRule.getAssessscheme())
//                                .append("\n");
//                        ruleIndex++;
//                    }
//                }
//            }
//        }
//        String rulesText = rulesBuilder.toString();
//        log.info("处理后的质检规则：{},质检总分：{}", rulesText, totalScoreSum);
//        //3.获取质检任务的转写文本
//        QmFileTask qmFileTask = baseMapper.selectById(qmtaskid);
//        String transcripttxtclob = qmFileTask.getTranscripttxtclob();
//        List<FileTransResponseResult.SentenceInfo> sentenceList = JSONUtil.toList(transcripttxtclob, FileTransResponseResult.SentenceInfo.class);
//        //3.1 转换任务对话文本
//        StringBuilder dialogueBuilder = new StringBuilder();
//        if (CollectionUtils.isNotEmpty(sentenceList)) {
//            for (FileTransResponseResult.SentenceInfo sentence : sentenceList) {
//                // 转换说话人标识为中文角色
//                String speakerRole = "未知";
//                if ("1".equals(sentence.getSpeakerId())) {
//                    speakerRole = "坐席";
//                } else if ("2".equals(sentence.getSpeakerId())) {
//                    speakerRole = "客户";
//                }
//                // 拼接主要对话内容行
//                dialogueBuilder.append(speakerRole).append("： 说话内容：")
//                        .append(sentence.getText() == null ? "" : sentence.getText()).append("。\n");
//                // 拼接详细信息行
//                dialogueBuilder.append(speakerRole).append(" （语速：").append(sentence.getSpeechRate())
//                        .append("/ 情绪：").append(sentence.getEmotionValue() / 10.0) // 假设情绪值需要除以10
//                        .append("/ 静音时长：").append(sentence.getSilenceDuration())
//                        .append(" /  开始时间（毫秒）：").append(sentence.getBeginTime())
//                        .append(" / 结束时间（毫秒）：").append(sentence.getEndTime()).append("\n");
//            }
//        }
//        String formattedDialogue = dialogueBuilder.toString();
//        log.info("转换后的对话文本：{}", formattedDialogue);
//
//        //4.拼接大模型提示词
//        // 4. 替换模板中的变量
//        String finalPrompt = promptTemplate
//                .replace("${text}", formattedDialogue)
//                .replace("${normal}", rulesText);
//        log.info("最终的提示词：{}", finalPrompt);
//        ChatRequest chatRequest = new ChatRequest();
//        chatRequest.setModel("qwen-plus");
//        chatRequest.setSystemPrompt("你是一个专业的质检助手,按照格式输出质检结果");
//        chatRequest.setUserPrompt(finalPrompt);
//        GenerationResult generationResult = DashScopeApi.callWithMessage(chatRequest);
//        String modelSummary = generationResult.getOutput().getChoices().get(0).getMessage().getContent();
//        //5.更新任务表字段。大模型生成的json，默认描述备注
//        QmFileTask qimFileTask = new QmFileTask();
//        qimFileTask.setQmtaskid(qmtaskid);
//        qimFileTask.setModelsummary(modelSummary);
//        QmModelSummary modelSummaryjson = JSONUtil.toBean(modelSummary, QmModelSummary.class);//转换为json 获取扣分总分
//        BigDecimal scoreSum = modelSummaryjson.getScores().stream()
//                .map(scoreItem -> new BigDecimal(scoreItem.getScore()))
//                .reduce(BigDecimal.ZERO, BigDecimal::add);
//        QualityScoreInfo qualityScoreInfo = new QualityScoreInfo();
//        qualityScoreInfo.setPassScore(adoptscore);//通过分数
//        qualityScoreInfo.setTotalDeduction(scoreSum);//扣分总分
//        qualityScoreInfo.setActualScore(totalScoreSum.subtract(scoreSum)); //totalScoreSum - scoreSum
//        qimFileTask.setQualityscore(JSONUtil.toJsonStr(qualityScoreInfo));//质检分数描述字段
//        qimFileTask.setModeltaskdesc(finalPrompt);
//        baseMapper.updateById(qimFileTask);
//        return new CmdResVo(1, "提交质检任务成功");
//
//    }
    @Override
    public CmdResVo submitQmTask(QmSubmitTaskReqVo paras) {
        Integer templateid = paras.getTemplateid();
        Long qmtaskid = paras.getQmtaskid();
        // 1. 先更新任务状态为"处理中"
        QmFileTask task = new QmFileTask();
        task.setQmtaskid(qmtaskid);
        task.setQmstatus("processing");
        task.setQmdatetime(new Date());
        baseMapper.updateById(task);
        // 2. 手动创建线程执行任务处理逻辑
        new Thread(() -> {
            try {
                processQmTaskAsync(templateid, qmtaskid);
            } catch (Exception e) {
                log.error("异步处理任务出错", e);
                // 出错时更新任务状态
                QmFileTask errorTask = new QmFileTask();
                errorTask.setQmtaskid(qmtaskid);
                errorTask.setQmstatus("error");
                baseMapper.updateById(errorTask);
            }
        }, "QmTask-Processor-" + qmtaskid).start();

        // 3. 立即返回，告知前端任务已受理
        return new CmdResVo(1, "质检任务已提交，正在处理中，请稍后查询结果");
    }

    @Override
    public CmdResVo startTranscript(StartTranscriptReqVo paras) {
        String qmtaskid = paras.getQmtaskid();
        String fileurl = paras.getFileurl();
        //1.根据任务id，查询任务信息
        QmFileTask qmFileTask = baseMapper.selectById(qmtaskid);
        if (qmFileTask == null) {
            return new CmdResVo(0, "任务不存在");
        }
        //如果没有转写文本启动转写
        if (qmFileTask.getTranscripttxtclob() == null) {
            //调取转写api
            try {
                FileTransResponseResult fileTransResponseResult = FileTransApi.processFileTrans(paras.getFileurl());
                assert fileTransResponseResult != null;
                List<FileTransResponseResult.SentenceInfo> sentenceList = fileTransResponseResult.getSentenceInfos();
                String jsonArray = JSONUtil.toJsonStr(sentenceList);
                qmFileTask.setTranscripttxtclob(jsonArray);
                baseMapper.updateById(qmFileTask);
            } catch (Exception e) {
                throw new RuntimeException("转写失败,录音文件异常", e);
            }
        }
        return new CmdResVo(1, qmFileTask.getQmtaskid().toString());
    }

    @Override
    public CmdResVo checkResult(String usrid, QmTaskCheckVo paras) {
        //1.根据任务id，查询任务信息
        QmFileTask qmFileTask = baseMapper.selectById(paras.getQmtaskid());
        if (qmFileTask == null) {
            throw new ServiceException(EnumRCode.VCodeNull.value, EnumRCode.NoFindSource.name);
        }
        qmFileTask.setRecheckuser(usrid);
        qmFileTask.setQmresult(paras.getIsok());
        baseMapper.updateById(qmFileTask);
        return new CmdResVo(1, qmFileTask.getQmtaskid().toString());
    }

    @Override
    public IPage<CallResVo> recordList(CallReqVo paras) {
        return baseMapper.recordList(new Page<>(paras.getPageNum(), paras.getPageSize()), paras);
    }
}